home *** CD-ROM | disk | FTP | other *** search
/ Shareware Super Platinum 8 / Shareware Super Platinum 8.iso / mac / DIAGTOOL / MEMSZ240.ZIP;1 / ITEMS.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1994-06-23  |  19.5 KB  |  899 lines
  1. /****************************************************************** ITEMS.CPP
  2.  *                                                                          *
  3.  *                     Display Item Class Functions                         *
  4.  *                                                                          *
  5.  ****************************************************************************/
  6.  
  7. #define INCL_BASE
  8. #define INCL_PM
  9. #include <os2.h>
  10.  
  11. #include <stdio.h>
  12. #include <stdlib.h>
  13. #include <string.h>
  14.  
  15. #include "debug.h"
  16. #include "support.h"
  17. #include "restring.h"
  18.  
  19. #include "items.h"
  20.  
  21.  
  22. VOID Item::Paint
  23. (
  24.   HPS hPS,
  25.   RECTL &Rectangle,
  26.   COLOR TextColor,
  27.   COLOR BackColor,
  28.   PSZ Text,
  29.   ULONG NewValue
  30. )
  31. {
  32.   WinDrawText ( hPS, strlen(PCHAR(Text)), Text, &Rectangle,
  33.     TextColor, BackColor, DT_RIGHT | DT_BOTTOM | DT_ERASERECT ) ;
  34.  
  35.   WinDrawText ( hPS, strlen(PCHAR(Label)), Label, &Rectangle,
  36.     TextColor, BackColor, DT_LEFT | DT_BOTTOM ) ;
  37.  
  38.   Value = NewValue ;
  39. }
  40.  
  41.  
  42. VOID Item::Measure ( HPS hPS, RECTL &Rectangle ) {
  43.    BYTE Text [100] ;
  44.    sprintf ( PCHAR(Text), "%s 1,234,567K", QueryLabel() ) ;
  45.    WinQueryWindowRect ( HWND_DESKTOP, &Rectangle ) ;
  46.    WinDrawText ( hPS, strlen(PCHAR(Text)), Text, &Rectangle, 0L, 0L, DT_LEFT | DT_BOTTOM | DT_QUERYEXTENT ) ;
  47. }
  48.  
  49.  
  50. VOID Clock::Measure ( HPS hPS, RECTL &Rectangle ) {
  51.    BYTE Text [100] ;
  52.    sprintf ( PCHAR(Text), " MMM, MM-DD HH:MMx " ) ;
  53.    WinQueryWindowRect ( HWND_DESKTOP, &Rectangle ) ;
  54.    WinDrawText ( hPS, strlen(PCHAR(Text)), Text, &Rectangle, 0L, 0L, DT_LEFT | DT_BOTTOM | DT_QUERYEXTENT ) ;
  55. }
  56.  
  57.  
  58. ULONG Clock::NewValue ( void ) {
  59.  
  60.   DATETIME DateTime ;
  61.   DosGetDateTime ( &DateTime ) ;
  62.  
  63.   ULONG Time ;
  64.   Time  = DateTime.weekday ;
  65.   Time *= 100 ;
  66.   Time += DateTime.month ;
  67.   Time *= 100 ;
  68.   Time += DateTime.day ;
  69.   Time *= 100 ;
  70.   Time += DateTime.hours ;
  71.   Time *= 100 ;
  72.   Time += DateTime.minutes ;
  73.  
  74.   return ( Time ) ;
  75. }
  76.  
  77.  
  78. VOID Clock::Repaint
  79. (
  80.   HPS hPS,
  81.   RECTL &Rectangle,
  82.   COLOR TextColor,
  83.   COLOR BackColor,
  84.   BOOL Mandatory
  85. )
  86. {
  87.   ULONG Time = NewValue ( ) ;
  88.  
  89.   if ( Mandatory || ( Time != Value ) )
  90.   {
  91.     BYTE Text [100] ;
  92.     ULONG Dow    = ( Time % 1000000000L ) / 100000000L ;
  93.     ULONG Month  = ( Time % 100000000L )  / 1000000L ;
  94.     ULONG Day    = ( Time % 1000000L )    / 10000L ;
  95.     ULONG Hour   = ( Time % 10000L )      / 100L ;
  96.     ULONG Minute = ( Time % 100L ) ;
  97.  
  98.     sprintf ( PCHAR(Text), "%0.3s, ", PSZ(*DaysOfWeek) + Dow*3 ) ;
  99.  
  100.     switch ( CountryInfo.fsDateFmt )
  101.     {
  102.       case DATEFMT_DD_MM_YY:
  103.         sprintf ( PCHAR(Text)+strlen(PCHAR(Text)), "%02lu%s%02lu ",
  104.           Day, CountryInfo.szDateSeparator, Month ) ;
  105.         break ;
  106.  
  107.       case DATEFMT_YY_MM_DD:
  108.       case DATEFMT_MM_DD_YY:
  109.       default:
  110.         sprintf ( PCHAR(Text)+strlen(PCHAR(Text)), "%02lu%s%02lu ",
  111.           Month, CountryInfo.szDateSeparator, Day ) ;
  112.         break ;
  113.     }
  114.  
  115.     if ( CountryInfo.fsTimeFmt )
  116.     {
  117.       sprintf ( PCHAR(Text)+strlen(PCHAR(Text)), "%02lu%s%02lu",
  118.         Hour,
  119.         CountryInfo.szTimeSeparator,
  120.         Minute ) ;
  121.     }
  122.     else
  123.     {
  124.       PCHAR AmPm ;
  125.  
  126.       if ( Hour )
  127.       {
  128.         if ( Hour < 12 )
  129.         {
  130.           AmPm = szAm ;
  131.         }
  132.         else if ( Hour == 12 )
  133.         {
  134.           if ( Minute )
  135.             AmPm = szPm ;
  136.           else
  137.             AmPm = szAm ;
  138.         }
  139.         else if ( Hour > 12 )
  140.         {
  141.           Hour -= 12 ;
  142.           AmPm = szPm ;
  143.         }
  144.       }
  145.       else
  146.       {
  147.         Hour = 12 ;
  148.         if ( Minute )
  149.           AmPm = szAm ;
  150.         else
  151.           AmPm = szPm ;
  152.       }
  153.       sprintf ( PCHAR(Text)+strlen(PCHAR(Text)), "%02lu%s%02lu%s",
  154.         Hour, CountryInfo.szTimeSeparator, Minute, AmPm ) ;
  155.     }
  156.  
  157.     Paint ( hPS, Rectangle, TextColor, BackColor, Text, Time ) ;
  158.  
  159.     WinDrawText ( hPS, strlen(PCHAR(Text)), Text, &Rectangle,
  160.       TextColor, BackColor, DT_CENTER | DT_BOTTOM | DT_ERASERECT ) ;
  161.  
  162.     Value = Time ;
  163.   }
  164. }
  165.  
  166.  
  167. VOID ElapsedTime::Measure ( HPS hPS, RECTL &Rectangle ) {
  168.    BYTE Text [100] ;
  169.    sprintf ( PCHAR(Text), "%s XX %s, XX:XX", QueryLabel(), PSZ(*Days) ) ;
  170.    WinQueryWindowRect ( HWND_DESKTOP, &Rectangle ) ;
  171.    WinDrawText ( hPS, strlen(PCHAR(Text)), Text, &Rectangle, 0L, 0L, DT_LEFT | DT_BOTTOM | DT_QUERYEXTENT ) ;
  172. }
  173.  
  174.  
  175. ULONG ElapsedTime::NewValue ( void )
  176. {
  177.   ULONG Milliseconds ;
  178.   DosQuerySysInfo ( QSV_MS_COUNT, QSV_MS_COUNT, &Milliseconds, sizeof(Milliseconds) ) ;
  179.   return ( Milliseconds / 60000L ) ;
  180. }
  181.  
  182.  
  183. VOID ElapsedTime::Repaint
  184. (
  185.   HPS hPS,
  186.   RECTL &Rectangle,
  187.   COLOR TextColor,
  188.   COLOR BackColor,
  189.   BOOL Mandatory
  190. )
  191. {
  192.   ULONG Time = NewValue ( ) ;
  193.  
  194.   if ( Mandatory || ( Time != Value ) ) {
  195.     BYTE Text [100] ;
  196.     memset ( Text, 0, sizeof(Text) ) ;
  197.  
  198.     ULONG NumberOfDays = Time / ( 60L * 24L ) ;
  199.  
  200.     if ( NumberOfDays ) {
  201.       sprintf ( PCHAR(Text), "%lu %s, ",
  202.         NumberOfDays, NumberOfDays > 1 ? PSZ(*Days) : PSZ(*Day) ) ;
  203.     }
  204.  
  205.     ULONG Minutes = Time % ( 60L * 24L ) ;
  206.  
  207.     sprintf ( PCHAR(Text+strlen(PCHAR(Text))), "%lu%s%02lu",
  208.       Minutes/60, CountryInfo.szTimeSeparator, Minutes%60 ) ;
  209.  
  210.     Paint ( hPS, Rectangle, TextColor, BackColor, Text, Time ) ;
  211.   }
  212. }
  213.  
  214.  
  215. APIRET16 APIENTRY16 Dos16MemAvail ( PULONG pulAvailMem ) ;
  216.  
  217. ULONG MemoryFree::NewValue ( void ) {
  218.   ULONG Space ;
  219.   Dos16MemAvail ( &Space ) ;
  220.   return ( Space ) ;
  221. }
  222.  
  223.  
  224. VOID MemoryFree::Repaint
  225. (
  226.   HPS hPS,
  227.   RECTL &Rectangle,
  228.   COLOR TextColor,
  229.   COLOR BackColor,
  230.   BOOL Mandatory
  231. )
  232. {
  233.   ULONG Size = NewValue ( ) ;
  234.  
  235.   if ( Mandatory || ( Size != Value ) ) {
  236.     BYTE Text [100] ;
  237.  
  238.     if ( Size < 0x80000 )
  239.       sprintf ( (PCHAR)Text, "%lu", Size ) ;
  240.     else
  241.       sprintf ( (PCHAR)Text, "%lu", (Size+512)/1024 ) ;
  242.  
  243.     {
  244.       PBYTE p1, p2 ;
  245.       BYTE Work[100] ;
  246.  
  247.       p1 = Text ;
  248.       p2 = Work ;
  249.       while ( *p1 )
  250.       {
  251.         *p2 = *p1 ;
  252.         p1 ++ ;
  253.         p2 ++ ;
  254.         if ( *p1 )
  255.         {
  256.           if ( strlen((PCHAR)p1) % 3 == 0 )
  257.           {
  258.             *p2 = CountryInfo.szThousandsSeparator [0] ;
  259.             p2 ++ ;
  260.           }
  261.         }
  262.       }
  263.       *p2 = 0 ;
  264.       strcpy ( (PCHAR)Text, (PCHAR)Work ) ;
  265.     }
  266.  
  267.     Text[strlen(PCHAR(Text))+1] = 0 ;
  268.     if ( Size < 0x80000 )
  269.       Text[strlen((PCHAR)Text)] = ' ' ;
  270.     else
  271.       Text[strlen((PCHAR)Text)] = 'K' ;
  272.  
  273.     Paint ( hPS, Rectangle, TextColor, BackColor, Text, Size ) ;
  274.   }
  275. }
  276.  
  277.  
  278. ULONG VirtualFree::NewValue ( void ) {
  279.   ULONG Space ;
  280.   DosQuerySysInfo ( QSV_TOTAVAILMEM, QSV_TOTAVAILMEM, &Space, sizeof(Space) ) ;
  281.   return ( Space ) ;
  282. }
  283.  
  284.  
  285. VOID VirtualFree::Repaint
  286. (
  287.   HPS hPS,
  288.   RECTL &Rectangle,
  289.   COLOR TextColor,
  290.   COLOR BackColor,
  291.   BOOL Mandatory
  292. )
  293. {
  294.   ULONG Size = NewValue ( ) ;
  295.  
  296.   if ( Mandatory || ( Size != Value ) ) {
  297.     BYTE Text [100] ;
  298.  
  299.     if ( Size < 0x80000 )
  300.       sprintf ( (PCHAR)Text, "%lu", Size ) ;
  301.     else
  302.       sprintf ( (PCHAR)Text, "%lu", (Size+512)/1024 ) ;
  303.  
  304.     {
  305.       PBYTE p1, p2 ;
  306.       BYTE Work[100] ;
  307.  
  308.       p1 = Text ;
  309.       p2 = Work ;
  310.       while ( *p1 )
  311.       {
  312.         *p2 = *p1 ;
  313.         p1 ++ ;
  314.         p2 ++ ;
  315.         if ( *p1 )
  316.         {
  317.           if ( strlen((PCHAR)p1) % 3 == 0 )
  318.           {
  319.             *p2 = CountryInfo.szThousandsSeparator [0] ;
  320.             p2 ++ ;
  321.           }
  322.         }
  323.       }
  324.       *p2 = 0 ;
  325.       strcpy ( (PCHAR)Text, (PCHAR)Work ) ;
  326.     }
  327.  
  328.     Text[strlen(PCHAR(Text))+1] = 0 ;
  329.     if ( Size < 0x80000 )
  330.       Text[strlen((PCHAR)Text)] = ' ' ;
  331.     else
  332.       Text[strlen((PCHAR)Text)] = 'K' ;
  333.  
  334.     Paint ( hPS, Rectangle, TextColor, BackColor, Text, Size ) ;
  335.   }
  336. }
  337.  
  338.  
  339. ULONG SwapSize::NewValue ( void )
  340. {
  341.   char Path [_MAX_PATH+1] ;
  342.  
  343.   strcpy ( Path, (PCHAR)SwapPath ) ;
  344.  
  345.   if ( Path[strlen(Path)-1] != '\\' )
  346.   {
  347.     strcat ( Path, "\\" ) ;
  348.   }
  349.  
  350.   strcat ( Path, "SWAPPER.DAT" ) ;
  351.  
  352.   ULONG SwapSize = 0 ;
  353.   FILESTATUS3 Status ;
  354.   if ( DosQueryPathInfo ( (PSZ)Path, FIL_STANDARD, &Status, sizeof(Status) ) == 0 )
  355.   {
  356.     SwapSize = Status.cbFileAlloc ;
  357.   }
  358.  
  359.   return ( SwapSize ) ;
  360. }
  361.  
  362.  
  363. VOID SwapSize::Repaint
  364. (
  365.   HPS hPS,
  366.   RECTL &Rectangle,
  367.   COLOR TextColor,
  368.   COLOR BackColor,
  369.   BOOL Mandatory
  370. )
  371. {
  372.   ULONG Size = NewValue ( ) ;
  373.  
  374.   if ( Mandatory || ( Size != Value ) )
  375.   {
  376.     BYTE Text [100] ;
  377.  
  378.     if ( Size < 0x80000 )
  379.       sprintf ( (PCHAR)Text, "%lu", Size ) ;
  380.     else
  381.       sprintf ( (PCHAR)Text, "%lu", (Size+512)/1024 ) ;
  382.  
  383.     {
  384.       PBYTE p1, p2 ;
  385.       BYTE Work[100] ;
  386.  
  387.       p1 = Text ;
  388.       p2 = Work ;
  389.       while ( *p1 )
  390.       {
  391.         *p2 = *p1 ;
  392.         p1 ++ ;
  393.         p2 ++ ;
  394.         if ( *p1 )
  395.         {
  396.           if ( strlen((PCHAR)p1) % 3 == 0 )
  397.           {
  398.             *p2 = CountryInfo.szThousandsSeparator [0] ;
  399.             p2 ++ ;
  400.           }
  401.         }
  402.       }
  403.       *p2 = 0 ;
  404.       strcpy ( (PCHAR)Text, (PCHAR)Work ) ;
  405.     }
  406.  
  407.     Text[strlen(PCHAR(Text))+1] = 0 ;
  408.     if ( Size < 0x80000 )
  409.       Text[strlen((PCHAR)Text)] = ' ' ;
  410.     else
  411.       Text[strlen((PCHAR)Text)] = 'K' ;
  412.  
  413.     Paint ( hPS, Rectangle, TextColor, BackColor, Text, Size ) ;
  414.   }
  415. }
  416.  
  417.  
  418. ULONG SwapFree::NewValue ( void )
  419. {
  420.   char Path [_MAX_PATH+1] ;
  421.  
  422.   strcpy ( Path, (PCHAR)SwapPath ) ;
  423.   strcat ( Path, "\\SWAPPER.DAT" ) ;
  424.  
  425.   ULONG SwapFree = 0 ;
  426.   if ( Path[0] )
  427.   {
  428.     DosError ( FERR_DISABLEHARDERR ) ;
  429.     FSALLOCATE Allocation ;
  430.     DosQueryFSInfo ( Path[0]-'A'+1, FSIL_ALLOC,
  431.       (PBYTE)&Allocation, sizeof(Allocation) ) ;
  432.     DosError ( FERR_ENABLEHARDERR ) ;
  433.  
  434.     SwapFree = Allocation.cUnitAvail*Allocation.cSectorUnit*Allocation.cbSector ;
  435.   }
  436.  
  437.   if ( SwapFree < ULONG(MinFree*1024L) )
  438.     return ( 0L ) ;
  439.   else
  440.     return ( SwapFree - ULONG(MinFree*1024L) ) ;
  441. }
  442.  
  443.  
  444. VOID SwapFree::Repaint
  445. (
  446.   HPS hPS,
  447.   RECTL &Rectangle,
  448.   COLOR TextColor,
  449.   COLOR BackColor,
  450.   BOOL Mandatory
  451. )
  452. {
  453.   ULONG Size = NewValue ( ) ;
  454.  
  455.   if ( Mandatory || ( Size != Value ) )
  456.   {
  457.     BYTE Text [100] ;
  458.  
  459.     if ( Size < 0x80000 )
  460.       sprintf ( (PCHAR)Text, "%lu", Size ) ;
  461.     else
  462.       sprintf ( (PCHAR)Text, "%lu", (Size+512)/1024 ) ;
  463.  
  464.     {
  465.       PBYTE p1, p2 ;
  466.       BYTE Work[100] ;
  467.  
  468.       p1 = Text ;
  469.       p2 = Work ;
  470.       while ( *p1 )
  471.       {
  472.         *p2 = *p1 ;
  473.         p1 ++ ;
  474.         p2 ++ ;
  475.         if ( *p1 )
  476.         {
  477.           if ( strlen((PCHAR)p1) % 3 == 0 )
  478.           {
  479.             *p2 = CountryInfo.szThousandsSeparator [0] ;
  480.             p2 ++ ;
  481.           }
  482.         }
  483.       }
  484.       *p2 = 0 ;
  485.       strcpy ( (PCHAR)Text, (PCHAR)Work ) ;
  486.     }
  487.  
  488.     Text[strlen(PCHAR(Text))+1] = 0 ;
  489.     if ( Size < 0x80000 )
  490.       Text[strlen((PCHAR)Text)] = ' ' ;
  491.     else
  492.       Text[strlen((PCHAR)Text)] = 'K' ;
  493.  
  494.     Paint ( hPS, Rectangle, TextColor, BackColor, Text, Size ) ;
  495.   }
  496. }
  497.  
  498.  
  499. ULONG SpoolSize::NewValue ( void )
  500. {
  501.   ULONG PathSize ;
  502.   DosQuerySysInfo ( QSV_MAX_PATH_LENGTH, QSV_MAX_PATH_LENGTH, &PathSize, sizeof(PathSize) ) ;
  503.  
  504.   PBYTE Path = PBYTE ( malloc ( PathSize ) ) ;
  505.   if ( Path == NULL )
  506.   {
  507. //  Log ( "ERROR: Unable to allocate memory for spool-file search path.\r\n" ) ;
  508.     return ( 0 ) ;
  509.   }
  510.  
  511.   PFILEFINDBUF3 Found = PFILEFINDBUF3 ( malloc ( PathSize + sizeof(FILEFINDBUF3) ) ) ;
  512.   if ( Found == NULL )
  513.   {
  514. //  Log ( "ERROR: Unable to allocate memory for spool-file search result structure.\r\n" ) ;
  515.     free ( Path ) ;
  516.     return ( 0 ) ;
  517.   }
  518.  
  519.   strcpy ( (PCHAR)Path, (PCHAR)SpoolPath ) ;
  520.   strcat ( (PCHAR)Path, "\\*.*" ) ;
  521.  
  522.   HDIR hDir = (HDIR) HDIR_CREATE ;
  523.   ULONG Count = 1 ;
  524.   ULONG TotalSize = 0 ;
  525.  
  526.   if ( !DosFindFirst2 ( Path, &hDir,
  527.     FILE_NORMAL | FILE_READONLY | FILE_DIRECTORY | FILE_ARCHIVED,
  528.     Found, PathSize+sizeof(FILEFINDBUF3), &Count, FIL_STANDARD ) )
  529.   {
  530.  
  531.     do
  532.     {
  533.  
  534.       if ( !strcmp ( (PCHAR)Found->achName, "." )
  535.         OR !strcmp ( (PCHAR)Found->achName, ".." ) )
  536.       {
  537.         continue ;
  538.       }
  539.  
  540.       if ( Found->attrFile & FILE_DIRECTORY )
  541.       {
  542.         HDIR hDir2 = (HDIR) HDIR_CREATE ;
  543.  
  544.         strcpy ( (PCHAR)Path, (PCHAR)SpoolPath ) ;
  545.         strcat ( (PCHAR)Path, "\\" ) ;
  546.         strcat ( (PCHAR)Path, (PCHAR)Found->achName ) ;
  547.         strcat ( (PCHAR)Path, "\\*.*" ) ;
  548.  
  549.         ULONG Count2 = 1 ;
  550.         if ( !DosFindFirst2 ( Path, &hDir2,
  551.           FILE_NORMAL | FILE_READONLY | FILE_ARCHIVED,
  552.           Found, PathSize+sizeof(FILEFINDBUF3), &Count2, FIL_STANDARD ) )
  553.         {
  554.           do
  555.           {
  556.             TotalSize += Found->cbFileAlloc ;
  557.           }
  558.           while ( !DosFindNext ( hDir2, Found, PathSize+sizeof(FILEFINDBUF3), &Count2 ) ) ;
  559.           DosFindClose ( hDir2 ) ;
  560.         }
  561.       }
  562.  
  563.       else
  564.       {
  565.         TotalSize += Found->cbFileAlloc ;
  566.       }
  567.     }
  568.     while ( !DosFindNext ( hDir, Found, PathSize+sizeof(FILEFINDBUF3), &Count ) ) ;
  569.  
  570.     DosFindClose ( hDir ) ;
  571.   }
  572.  
  573.   free ( Path ) ;
  574.   free ( Found ) ;
  575.  
  576.   return ( TotalSize ) ;
  577. }
  578.  
  579.  
  580. VOID SpoolSize::Repaint
  581. (
  582.   HPS hPS,
  583.   RECTL &Rectangle,
  584.   COLOR TextColor,
  585.   COLOR BackColor,
  586.   BOOL Mandatory
  587. )
  588. {
  589.   ULONG Size = NewValue ( ) ;
  590.  
  591.   if ( Mandatory || ( Size != Value ) )
  592.   {
  593.     BYTE Text [100] ;
  594.  
  595.     if ( Size < 0x80000 )
  596.       sprintf ( (PCHAR)Text, "%lu", Size ) ;
  597.     else
  598.       sprintf ( (PCHAR)Text, "%lu", (Size+512)/1024 ) ;
  599.  
  600.     {
  601.       PBYTE p1, p2 ;
  602.       BYTE Work[100] ;
  603.  
  604.       p1 = Text ;
  605.       p2 = Work ;
  606.       while ( *p1 )
  607.       {
  608.         *p2 = *p1 ;
  609.         p1 ++ ;
  610.         p2 ++ ;
  611.         if ( *p1 )
  612.         {
  613.           if ( strlen((PCHAR)p1) % 3 == 0 )
  614.           {
  615.             *p2 = CountryInfo.szThousandsSeparator [0] ;
  616.             p2 ++ ;
  617.           }
  618.         }
  619.       }
  620.       *p2 = 0 ;
  621.       strcpy ( (PCHAR)Text, (PCHAR)Work ) ;
  622.     }
  623.  
  624.     Text[strlen(PCHAR(Text))+1] = 0 ;
  625.     if ( Size < 0x80000 )
  626.       Text[strlen((PCHAR)Text)] = ' ' ;
  627.     else
  628.       Text[strlen((PCHAR)Text)] = 'K' ;
  629.  
  630.     Paint ( hPS, Rectangle, TextColor, BackColor, Text, Size ) ;
  631.   }
  632. }
  633.  
  634.  
  635. ULONG CpuLoad::NewValue ( void ) {
  636.   MaxCount = (ULONG) max ( MaxCount, *IdleCount ) ;
  637.   ULONG Load = ( ( MaxCount - *IdleCount ) * 100 ) / MaxCount ;
  638.   return ( Load ) ;
  639. }
  640.  
  641.  
  642. VOID CpuLoad::Repaint
  643. (
  644.   HPS hPS,
  645.   RECTL &Rectangle,
  646.   COLOR TextColor,
  647.   COLOR BackColor,
  648.   BOOL Mandatory
  649. )
  650. {
  651.   ULONG Load = NewValue ( ) ;
  652.  
  653.   if ( Mandatory || ( Load != Value ) )
  654.   {
  655.     BYTE Text [100] ;
  656.     sprintf ( (PCHAR)Text, "%lu%%", Load ) ;
  657.     Paint ( hPS, Rectangle, TextColor, BackColor, Text, Load ) ;
  658.   }
  659. }
  660.  
  661.  
  662. ULONG TaskCount::NewValue ( void )
  663. {
  664.   return ( WinQuerySwitchList ( Anchor, PSWBLOCK(NULL), 0 ) ) ;
  665. }
  666.  
  667.  
  668. VOID TaskCount::Repaint
  669. (
  670.   HPS hPS,
  671.   RECTL &Rectangle,
  672.   COLOR TextColor,
  673.   COLOR BackColor,
  674.   BOOL Mandatory
  675. )
  676. {
  677.   ULONG Count = NewValue ( ) ;
  678.  
  679.   if ( Mandatory || ( Count != Value ) )
  680.   {
  681.     BYTE Text [100] ;
  682.     sprintf ( (PCHAR)Text, "%lu ", Count ) ;
  683.     Paint ( hPS, Rectangle, TextColor, BackColor, Text, Count ) ;
  684.   }
  685. }
  686.  
  687.  
  688. VOID DriveFree::Measure ( HPS hPS, RECTL &Rectangle ) {
  689.    BYTE Text [100] ;
  690.    if ( ShowFileSystemName ) {
  691.       if ( ShowDiskLabel ) {
  692.          sprintf ( PCHAR(Text), "%s (%s,%s) 1,234,567K", QueryLabel(), DiskLabel, FileSystem ) ;
  693.       } else {
  694.          sprintf ( PCHAR(Text), "%s (%s) 1,234,567K", QueryLabel(), FileSystem ) ;
  695.       } /* endif */
  696.    } else {
  697.       if ( ShowDiskLabel ) {
  698.          sprintf ( PCHAR(Text), "%s (%s) 1,234,567K", QueryLabel(), DiskLabel ) ;
  699.       } else {
  700.          sprintf ( PCHAR(Text), "%s 1,234,567K", QueryLabel() ) ;
  701.       } /* endif */
  702.    } /* endif */
  703.    WinQueryWindowRect ( HWND_DESKTOP, &Rectangle ) ;
  704.    WinDrawText ( hPS, strlen(PCHAR(Text)), Text, &Rectangle, 0L, 0L, DT_LEFT | DT_BOTTOM | DT_QUERYEXTENT ) ;
  705. }
  706.  
  707.  
  708. ULONG DriveFree::NewValue ( void )
  709. {
  710.   if ( Error )
  711.   {
  712.     return ( 0 ) ;
  713.   }
  714.  
  715.   DosError ( FERR_DISABLEHARDERR ) ;
  716.  
  717.   FSALLOCATE Allocation ;
  718.   USHORT Status = DosQueryFSInfo ( DriveNumber, FSIL_ALLOC, (PBYTE)&Allocation, sizeof(Allocation) ) ;
  719.  
  720.   DosError ( FERR_ENABLEHARDERR ) ;
  721.  
  722.   if ( Status )
  723.   {
  724.     Error = TRUE ;
  725.     return ( 0 ) ;
  726.   }
  727.  
  728.   return ( Allocation.cUnitAvail*Allocation.cSectorUnit*Allocation.cbSector ) ;
  729. }
  730.  
  731.  
  732. VOID DriveFree::Repaint
  733. (
  734.   HPS hPS,
  735.   RECTL &Rectangle,
  736.   COLOR TextColor,
  737.   COLOR BackColor,
  738.   BOOL Mandatory
  739. )
  740. {
  741.   ULONG Size = NewValue ( ) ;
  742.  
  743.   if ( Mandatory || ( Size != Value ) )
  744.   {
  745.     BYTE Text [100] ;
  746.  
  747.     if ( Error )
  748.     {
  749.       strcpy ( PCHAR(Text), PCHAR(*DriveError) ) ;
  750.     }
  751.     else
  752.     {
  753.       if ( Size < 0x80000 )
  754.         sprintf ( (PCHAR)Text, "%lu", Size ) ;
  755.       else
  756.         sprintf ( (PCHAR)Text, "%lu", (Size+512)/1024 ) ;
  757.  
  758.       {
  759.         PBYTE p1, p2 ;
  760.         BYTE Work[100] ;
  761.  
  762.         p1 = Text ;
  763.         p2 = Work ;
  764.         while ( *p1 )
  765.         {
  766.           *p2 = *p1 ;
  767.           p1 ++ ;
  768.           p2 ++ ;
  769.           if ( *p1 )
  770.           {
  771.             if ( strlen((PCHAR)p1) % 3 == 0 )
  772.             {
  773.               *p2 = CountryInfo.szThousandsSeparator [0] ;
  774.               p2 ++ ;
  775.             }
  776.           }
  777.         }
  778.         *p2 = 0 ;
  779.         strcpy ( (PCHAR)Text, (PCHAR)Work ) ;
  780.       }
  781.  
  782.       Text[strlen(PCHAR(Text))+1] = 0 ;
  783.       if ( Size < 0x80000 )
  784.         Text[strlen((PCHAR)Text)] = ' ' ;
  785.       else
  786.         Text[strlen((PCHAR)Text)] = 'K' ;
  787.     }
  788.  
  789.     WinDrawText ( hPS, strlen(PCHAR(Text)), Text, &Rectangle,
  790.       TextColor, BackColor, DT_RIGHT | DT_BOTTOM | DT_ERASERECT ) ;
  791.  
  792.     if ( ShowFileSystemName ) {
  793.        if ( ShowDiskLabel ) {
  794.           sprintf ( PCHAR(Text), "%s (%s,%s)", QueryLabel(), DiskLabel, FileSystem ) ;
  795.        } else {
  796.           sprintf ( PCHAR(Text), "%s (%s)", QueryLabel(), FileSystem ) ;
  797.        } /* endif */
  798.     } else {
  799.        if ( ShowDiskLabel ) {
  800.           sprintf ( PCHAR(Text), "%s (%s)", QueryLabel(), DiskLabel ) ;
  801.        } else {
  802.           sprintf ( PCHAR(Text), "%s", QueryLabel() ) ;
  803.        } /* endif */
  804.     } /* endif */
  805.     
  806.     WinDrawText ( hPS, strlen(PCHAR(Text)), Text, &Rectangle,
  807.       TextColor, BackColor, DT_LEFT | DT_BOTTOM ) ;
  808.  
  809.     Value = Size ;
  810.   }
  811. }
  812.  
  813.  
  814. ULONG TotalFree::NewValue ( void )
  815. {
  816.   ULONG Free = 0 ;
  817.   ULONG Mask = Drives >> 2 ;
  818.  
  819.   for ( int Drive=3; Drive<=26; Drive++ )
  820.   {
  821.     if ( Mask & 1 )
  822.     {
  823.       DosError ( FERR_DISABLEHARDERR ) ;
  824.  
  825.       FSALLOCATE Allocation ;
  826.       USHORT Status = DosQueryFSInfo ( Drive, FSIL_ALLOC, (PBYTE)&Allocation, sizeof(Allocation) ) ;
  827.  
  828.       DosError ( FERR_ENABLEHARDERR ) ;
  829.  
  830.       if ( Status )
  831.       {
  832.         Drives &= ~ ( 1 << (Drive-1) ) ;
  833.       }
  834.       else
  835.       {
  836.         Free += Allocation.cUnitAvail*Allocation.cSectorUnit*Allocation.cbSector ;
  837.       }
  838.     }
  839.     Mask >>= 1 ;
  840.   }
  841.  
  842.   return ( Free ) ;
  843. }
  844.  
  845.  
  846. VOID TotalFree::Repaint
  847. (
  848.   HPS hPS,
  849.   RECTL &Rectangle,
  850.   COLOR TextColor,
  851.   COLOR BackColor,
  852.   BOOL Mandatory
  853. )
  854. {
  855.   ULONG Size = NewValue ( ) ;
  856.  
  857.   if ( Mandatory || ( Size != Value ) )
  858.   {
  859.     BYTE Text [100] ;
  860.  
  861.     if ( Size < 0x80000 )
  862.       sprintf ( (PCHAR)Text, "%lu", Size ) ;
  863.     else
  864.       sprintf ( (PCHAR)Text, "%lu", (Size+512)/1024 ) ;
  865.  
  866.     {
  867.       PBYTE p1, p2 ;
  868.       BYTE Work[100] ;
  869.  
  870.       p1 = Text ;
  871.       p2 = Work ;
  872.       while ( *p1 )
  873.       {
  874.         *p2 = *p1 ;
  875.         p1 ++ ;
  876.         p2 ++ ;
  877.         if ( *p1 )
  878.         {
  879.           if ( strlen((PCHAR)p1) % 3 == 0 )
  880.           {
  881.             *p2 = CountryInfo.szThousandsSeparator [0] ;
  882.             p2 ++ ;
  883.           }
  884.         }
  885.       }
  886.       *p2 = 0 ;
  887.       strcpy ( (PCHAR)Text, (PCHAR)Work ) ;
  888.     }
  889.  
  890.     Text[strlen(PCHAR(Text))+1] = 0 ;
  891.     if ( Size < 0x80000 )
  892.       Text[strlen((PCHAR)Text)] = ' ' ;
  893.     else
  894.       Text[strlen((PCHAR)Text)] = 'K' ;
  895.  
  896.     Paint ( hPS, Rectangle, TextColor, BackColor, Text, Size ) ;
  897.   }
  898. }
  899.